home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 27 / CU Amiga Magazine's Super CD-ROM 27 (1998)(EMAP Images)(GB)[!][issue 1998-10].iso / CUCD / Magazine / Networking / EmuNet09b / socket / stest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-07-22  |  29.8 KB  |  967 lines
  1. /*========================================================*/
  2. /*-SOURCE OF     (stest.c)  ------------------------------*/
  3. /*--------------------------------------------------------*/
  4. /* (C) Jul/1998  Dr. Adil Temel    (atemel@hotmail.com)      */
  5. /*--------------------------------------------------------*/
  6. /* stest.c      : BSD Socket test & RAW transfer speed    */
  7. /* Created      : 19980710 03:41:42 Fri                */
  8. /* Last Modified: 19980712 19:06:52 Sun              */
  9. /*========================================================*/
  10.  
  11. #define VERSION "0.5"
  12. /*--------------------------------------------------------*/
  13. #define PORTNUM 50000         /* random port number, we need something */
  14. /*--------------------------------------------------------*/
  15. #define MAXDATA (2*1024*1024L)  /* 1024K transfer */
  16. /*--------------------------------------------------------*/
  17. #define MAXBUF (1024L)          /* Unit of transfer */
  18. /*--------------------------------------------------------*/
  19. #define DUMPLEN (0x40)          /* dump last received/sent data */
  20. /*--------------------------------------------------------*/
  21. #include <errno.h>
  22. #include <signal.h>
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <time.h>
  26.  
  27. #include <unistd.h>
  28. #include <sys/types.h>
  29. #include <sys/socket.h>
  30. #include <sys/wait.h>
  31. #include <netinet/in.h>
  32. #include <netdb.h>
  33.  
  34. /*--------------------------------------------------------*/
  35. #ifdef AMIGA
  36. /*--------------------------------------------------------*/
  37. #include <exec/types.h>
  38. /*--------------------------------------------------------*/
  39. #else
  40. typedef signed long     LONG;        /* signed 32-bit quantity */
  41. typedef unsigned long    ULONG;        /* unsigned 32-bit quantity */
  42. typedef signed short     WORD;        /* signed 16-bit quantity */
  43. typedef unsigned short    UWORD;        /* unsigned 16-bit quantity */
  44. typedef signed char     BYTE;        /* signed 8-bit quantity */
  45. typedef unsigned char    UBYTE;        /* unsigned 8-bit quantity */
  46. #endif
  47.  
  48.  
  49.  
  50. #define COMPILENAME "SocketTest"
  51. /*--------------------------------------------------------*/
  52. #define PROGRAMNAME COMPILENAME " V" VERSION
  53. /*--------------------------------------------------------*/
  54. #define COPYRIGHT  PROGRAMNAME" Test BSD socket communication.\n"  \
  55.            "Written by Dr. Adil Temel (E-Mail: atemel@hotmail.com) (C) 1998\r\n"
  56. /*--------------------------------------------------------*/
  57.  
  58. #ifndef MAXHOSTNAME
  59. #define MAXHOSTNAME 256
  60. #endif
  61. #define RETSIGTYPE void
  62.  
  63. /*--------------------------------------------------------*/
  64. long ntol(char *s);
  65. char sw_server=0,sw_quiet=0,sw_verbose=0,sw_random=0;
  66. char sw_debug=0,sw_checksum=0,sw_readback=0;
  67. char sw_keepalive=0;
  68.  
  69. char *kw_hostname=NULL;
  70.  
  71. /*--------------------------------------------------------*/
  72. unsigned short int portnum=PORTNUM;
  73. /*--------------------------------------------------------*/
  74. long maxbuf=MAXBUF,maxdata=MAXDATA;
  75. char *bufptr=NULL;
  76.  
  77. /*--------------------------------------------------------*/
  78. #ifndef TRUE
  79. #define TRUE 1
  80. #define FALSE 0
  81. #endif
  82. /*--------------------------------------------------------*/
  83. RETSIGTYPE fireman(int x);
  84. int get_connection(int s);
  85. int establish(unsigned short portnum);
  86. int call_socket(char *hostname, unsigned short portnum);
  87. int mygethostname(char *hostname,int maxlen);
  88. struct hostent *mygethostent(char *hostname);
  89. /*--------------------------------------------------------*/
  90. int send_long(int s, long l);
  91. int send_word(int s, short l);
  92. int send_byte(int s, char l);
  93. /*--------------------------------------------------------*/
  94. int  get_long(int s, long *l);
  95. int  get_word(int s, short *l);
  96. int  get_byte(int s, char *l);
  97. /*--------------------------------------------------------*/
  98. int read_data (int s,char *buf,int n);
  99. int write_data(int s,char *buf,int n);
  100. /*--------------------------------------------------------*/
  101. int  receive_data(int s);
  102. int  send_data(void);
  103.  
  104. /*--------------------------------------------------------*/
  105. void CurrentTime(ULONG *s,ULONG *m);
  106. void DiffTime(ULONG *s1,ULONG *m1,ULONG s2,ULONG m2);
  107. char *SPrintTime(ULONG s,ULONG m);
  108. /*--------------------------------------------------------*/
  109. long  memrnd(void *d,long sd,long len);
  110. void  memcsum(void *d,ULONG *cs,long len);
  111. void  memdump(void *s,long len,long adr);
  112. char  *dumpadr(char *s,long len);
  113.  
  114. unsigned long RangeSeed(unsigned long s);
  115. unsigned short int RangeRand(int d6);
  116. /*--------------------------------------------------------*/
  117. int main(int argc,char **argv)
  118. { 
  119. int s, t;
  120. int i,x,ret;
  121. char *karg,skip,argused;
  122. printf(COPYRIGHT);
  123. //printf(COMPILEDATE);
  124. if(argc>=2)
  125. if(argv[1][0]=='?')
  126.   {
  127.     usage:
  128.     printf("Usage: "COMPILENAME" [OPTIONS]\n");
  129.     printf("Available options: (use with prefix - or /)\n");
  130.     printf("----------------------------------------------\n");
  131.     printf(" -s               Run as server\n");
  132.     printf(" -pPORTNUM        Use this portnumber\n");
  133.     printf(" -nHOSTNAME       Call which computer\n");
  134.     printf(" -bMAXBUF_K       Buffer sizeK    [1K]\n");
  135.     printf(" -eMAXDATA_K      Send data sizeK     [1024K]\n");
  136.     printf(" -r               Use randomized data (hardly compressible)\n");
  137.     printf(" -c               Use simple checksum\n");
  138.     printf(" -f               Read back written data\n");
  139.     printf(" -k               Use socket option: SO_KEEPALIVE\n");
  140.     printf(" -d               DEBUG\n");
  141.     exit(0);
  142.   }
  143. for(i=1;i<argc;i++)
  144.  if(argv[i][0]=='-' || argv[i][0]=='/')
  145.   {
  146.     karg=&argv[i][2];skip=0;argused=0;
  147.     if(!*karg)
  148.      {
  149.          karg=argv[i+1];skip=1;
  150.          if(!karg || *karg=='-' || *karg=='/') {karg="";skip=0;}
  151.      }
  152.     if(!karg) karg="";/* no NULL ptr */
  153.     switch(argv[i][1]|0x20)
  154.      {
  155.        case 'h':
  156.        case '?': goto usage;
  157.        case 'p': portnum=ntol(karg);argused=1;
  158.          if(!portnum) portnum=PORTNUM;
  159.          break;
  160.        case 'b': maxbuf=ntol(karg)*1024L;argused=1;
  161.          if(maxbuf<=0 || maxbuf>(512*1024L)) maxbuf=MAXBUF;
  162.          break;
  163.        case 'e': maxdata=ntol(karg)*1024L;argused=1;
  164.          if(maxdata<=0 || maxdata>(16384*1024L)) maxdata=MAXDATA;
  165.          break;
  166.        case 'n': kw_hostname=karg;argused=1;break;
  167.        case 'k': sw_keepalive=TRUE;break;
  168.        case 'c': sw_checksum=TRUE;break;
  169.        case 'f': sw_readback=TRUE;break;
  170.        case 'r': sw_random=TRUE;break;
  171.        case 's': sw_server=TRUE;break;
  172.        case 'd': sw_debug =TRUE;break;
  173.        case 'v': sw_verbose=TRUE;sw_quiet=FALSE;break;
  174.        case 'q': sw_verbose=FALSE;sw_quiet=TRUE;break;
  175.          break;
  176.        default:  printf("Unknown option %s ignored\n",argv[i]);
  177.      }
  178.     if(argused) i+=skip;
  179.   }
  180. bufptr=malloc(maxbuf);
  181. if(!bufptr)
  182.   {
  183.     fprintf(stderr,"Can't get %ld buffer.\n",maxbuf);
  184.     exit(1);
  185.   }
  186. printf("Using portnum %d , buf %ldK , data %ldK\n",(long) portnum,maxbuf>>10L,maxdata>>10L);
  187. if(!sw_server)
  188.  {
  189.     send_data();
  190.     exit(0);
  191.  }
  192. printf("Running as server..\n");
  193. if ((s= establish(portnum)) < 0) {  /* plug in the phone */
  194.     perror("establish");
  195.     exit(1);
  196.   }
  197. #if 0
  198.  signal(SIGCHLD, fireman);           /* this eliminates zombies */
  199. #endif
  200.   printf("Waiting for connections.\n");
  201.  
  202.   for (;;) {                          /* loop for phone calls */
  203.     if ((t= get_connection(s)) < 0) { /* get a connection */
  204.       if (errno == EINTR)             /* EINTR might happen on accept(), */
  205.         continue;                     /* try again */
  206.       perror("accept");               /* bad */
  207.       exit(1);
  208.     }
  209. #if 0 //#ifndef AMIGA
  210.     switch(fork()) {                  /* try to handle connection */
  211.     case -1 :                         /* bad news.  scream and die */
  212.       perror("fork");
  213.       close(s);
  214.       close(t);
  215.       exit(1);
  216.     case 0 :                          /* we're the child, do something */
  217.       close(s);
  218.       receive_data(t);
  219.       exit(0);
  220.     default :                         /* we're the parent so look for */
  221.       close(t);                       /* another connection */
  222.       continue;
  223.     }
  224. #else
  225.       receive_data(t);
  226.       close(t);
  227. #endif
  228.  
  229.   }
  230. }
  231.  
  232. /* as children die we should get catch their returns or else we get
  233.  * zombies, A Bad Thing.  fireman() catches falling children.
  234.  */
  235. RETSIGTYPE fireman(int x)
  236. {
  237.   //printf("fireman started.\n");
  238.   while (waitpid(-1,NULL,WNOHANG) > 0)  ;
  239.   //printf("fireman finished.\n");
  240. }
  241.  
  242.  
  243. long bytes_msec(ULONG b,ULONG s,ULONG m)
  244. {
  245. m=m/1000L+s*1000L;if(!m) m=1;
  246. b/=m;
  247. return b;
  248. }
  249. /*--------------------------------------------------------*/
  250. void say_result(char *info,ULONG tot,ULONG totb, ULONG s1,ULONG m1,ULONG s2,ULONG m2)
  251. {
  252. ULONG b;
  253. char *rwmode;
  254. DiffTime(&s1,&m1,s2,m2);
  255. tot+=totb;b=bytes_msec(tot,s1,m1);
  256. if(totb) 
  257.   {
  258.     rwmode= sw_server ? "READ/WRITE":"WRITE/READ";
  259.   }
  260. else
  261.   {
  262.     rwmode= sw_server ? "WRITE":"READ";
  263.   }
  264. printf("%s: total %ldK (%ld bytes) %s (%ld bytes/msec %ld bytes/sec %ldK/sec ).\n",
  265.         info,
  266.             tot/1024L,tot,rwmode,
  267.         b,b*1000L,b*1000L/1024L);
  268. printf("%s: elapsed Time ticks: %s\n",info,SPrintTime(s1,m1));
  269. }
  270.  
  271. /*--------------------------------------------------------*/
  272. #if 0
  273. /*
  274. After you create a socket to get calls, you must wait for calls to that
  275. socket. The accept() function is used to do this. Calling accept() is
  276. analogous to picking up the telephone if it's ringing. Accept() returns a
  277. new socket which is connected to the caller.
  278.  
  279. The following function can be used to accept a connection on a socket that
  280. has been created using the establish() function above:
  281. */
  282.  
  283. #endif
  284. /*--------------------------------------------------------*/
  285. #define PARMF_RAND     (1L<<0)
  286. #define PARMF_CSUM     (1L<<1)
  287. #define PARMF_RBACK    (1L<<2)
  288. #define PARMF_PSIG    (1L<<7) /* parameter id */
  289. /*--------------------------------------------------------*/
  290. #define START_BYTE     (0xAC)
  291. /*--------------------------------------------------------*/
  292. int send_data(void)
  293. {
  294.    int s,i,c;
  295.    ULONG l;
  296.    ULONG s1,s2,m1,m2;
  297.    ULONG len,tot=0,totb=0,csum=0,rs=0;
  298.    UBYTE x=0;
  299.    char  name[MAXHOSTNAME+1];
  300.    UBYTE parm=PARMF_PSIG;
  301.    if(sw_random  ) parm|=PARMF_RAND;
  302.    if(sw_checksum) parm|=PARMF_CSUM;
  303.    if(sw_readback) parm|=PARMF_RBACK;
  304.  
  305.    if(kw_hostname) strcpy(name,kw_hostname);
  306.    else mygethostname(name, MAXHOSTNAME);           /* who are we? */
  307.   
  308.    printf("send_data: sending to %s port %d\n",name,(long)portnum);
  309.    if( (s=call_socket(name,portnum)) <0)
  310.    {
  311.       fprintf(stderr,"cannot connect.\n");
  312.       return -1;
  313.     }
  314.    len=maxdata;
  315.    printf("send_data: socket %d , sending %ld\n",s,len);
  316.    if(send_long(s,len)<0)
  317.     {
  318.       error:
  319.       printf("send_data: failed to send parameter!\n");
  320.       goto fin;
  321.     }
  322.    if(send_byte(s,parm)>=0)
  323.     {
  324.        if(parm& PARMF_RAND)  printf("send_data: will send random data.\n");
  325.        if(parm& PARMF_CSUM)  printf("send_data: will use checksum.\n");
  326.        if(parm& PARMF_RBACK) printf("send_data: will read back sent data\n");
  327.     }  else goto error;
  328.     len=maxdata;
  329.     if(len && len<maxbuf) l=len;else l=maxbuf;
  330.     if(!len) len=MAXBUF;/* default send length */
  331.     /* Dummy data */
  332.     if(parm & PARMF_RAND)
  333.      {
  334.          rs=memrnd(bufptr,time(NULL),l);
  335.          if(send_long(s,rs)<0) goto error;
  336.          printf("send_data: using random seed 0x%08lx\n",rs);
  337.      }
  338.     else  memset(bufptr,x++,l);
  339.     if(send_byte(s,START_BYTE)<0) goto error;
  340.     CurrentTime(&s1,&m1);
  341.     while(len && (c=write_data(s,bufptr,l)) >0 )
  342.      {
  343. #if 0
  344.         if(sw_random) memrnd(bufptr,-1,l);
  345.         else          memset(bufptr,x++,l);
  346. #endif
  347.     if(parm&PARMF_CSUM) memcsum(bufptr,&csum,l);
  348.         if(parm&PARMF_RBACK)
  349.       {
  350.         if(read_data(s,bufptr,c)<c)
  351.          {
  352.            printf("send_data: cannot read %d\n",c);
  353.            break;
  354.          } else totb+=c;
  355.           }
  356.         tot+=c;len-=c;
  357.         if(len<maxbuf) l=len;else l=maxbuf;
  358.      }
  359.     CurrentTime(&s2,&m2);
  360.     memdump(bufptr+c-DUMPLEN,DUMPLEN,tot-DUMPLEN);
  361.     say_result("send_data",tot,totb,s1,m1,s2,m2);
  362.     if(parm&PARMF_CSUM) 
  363.     {
  364.         printf("send_data: checksum 0x%08lx\n",csum);
  365.         send_long(s,csum);
  366.     }
  367. fin:
  368.   close(s);
  369.   printf("send_data: socket closed.\n");
  370.   return 0;
  371. }
  372.  
  373. /*--------------------------------------------------------*/
  374. /* this is the function that plays with the socket.it will*/
  375. /* be called after getting a connection.          */
  376. /*--------------------------------------------------------*/
  377. int receive_data(int s)
  378. {
  379.    int i,c;
  380.    ULONG l;
  381.    ULONG s1,s2,m1,m2;
  382.    ULONG len,tot=0,totb=0,csum=0,rs=0;
  383.    UBYTE parm=0;
  384.    UBYTE start;
  385.    printf("receive_data: socket %d\n",s);
  386.    if(get_long(s,&len)<0)
  387.     { 
  388.       error:
  389.       printf("receive_data: failed to read parameter!\n");
  390.       goto fin;
  391.     }
  392.     printf("receive_data: expecting %ld bytes\n",len);
  393.     if(get_byte(s,&parm)>=0)
  394.      {    
  395.        if(!(parm&PARMF_PSIG)) {printf("receive_data: wrong parameter received.\n");goto fin;}
  396.        if(parm&PARMF_RAND)  printf("receive_data: will receive random data.\n");
  397.        if(parm&PARMF_CSUM)  printf("receive_data: will use checksum.\n");
  398.        if(parm&PARMF_RBACK) printf("receive_data: will write back received data\n");
  399.      }
  400.     else goto error;
  401.  
  402.     if(parm&PARMF_RAND) 
  403.      {
  404.        if(get_long(s,&rs)<0) goto error;
  405.        printf("receive_data: remote random seed 0x%08lx\n",rs);
  406.      }
  407.     if(len && len<maxbuf) l=len;else l=maxbuf;
  408.     if(!len) len=0xFFFFFFFF;
  409.     if(get_byte(s,&start)) goto error;
  410.     if(start!=START_BYTE)
  411.      {
  412.     printf("receive_data: wrong start byte 0x%02lX (expecting 0x%02lX)\n",
  413.             start,START_BYTE);
  414.         goto error;
  415.       }
  416.     CurrentTime(&s1,&m1);
  417.     while(len && (c=read_data(s,bufptr,l)) >0 )
  418.      {
  419.     if(parm&PARMF_CSUM) memcsum(bufptr,&csum,l);
  420.         if(parm&PARMF_RBACK)
  421.       {
  422.         if(write_data(s,bufptr,c)<c)
  423.          {
  424.            printf("receive_data: cannot re-send received data %d\n",c);
  425.            break;
  426.          } else totb+=c;
  427.           }
  428.  
  429.         tot+=c;len-=c;
  430.         if(len<maxbuf) l=len;else l=maxbuf;
  431.      }
  432.      CurrentTime(&s2,&m2);
  433.      memdump(bufptr+c-DUMPLEN,DUMPLEN,tot-DUMPLEN);
  434.      say_result("receive_data",tot,totb,s1,m1,s2,m2);
  435.      if(parm&PARMF_CSUM) 
  436.     {
  437.       ULONG rsum;
  438.       get_long(s,&rsum);
  439.       printf("receive_data: checksum remote 0x%08lx%s0x%08lx %s\n",
  440.         rsum,rsum==csum ? "==":"!=",csum, rsum==csum ? "OK!":"FAILURE!!");
  441.     }
  442. fin:
  443. printf("receive_data: exit\n");
  444. return 0;
  445. }
  446. /*--------------------------------------------------------*/
  447. int ONE = 1;
  448. /*--------------------------------------------------------*/
  449. int sokeepalive(int s)
  450. {
  451. int r;
  452. printf("sokeepalive: keeping %d alive\n",s);
  453. r= setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, &ONE, sizeof ONE);
  454. printf("sokeepalive: setsockopt returned %d\n",r);
  455. return r;
  456. }
  457.  
  458. /*--------------------------------------------------------*/
  459. /* send a long lvalue across network              */
  460. /*--------------------------------------------------------*/
  461. int send_long(int s, long l)
  462. {
  463.    l=htonl(l);/* host to network long */
  464.    if(write_data(s,(char *)&l,sizeof(long))==sizeof(long)) return 0;
  465.    return -1;/* Failed */
  466. }
  467. /*--------------------------------------------------------*/
  468. /* get  a long lvalue from network              */
  469. /*--------------------------------------------------------*/
  470. int get_long(int s, long *l)
  471. {
  472. long x;
  473. if(read_data(s,(char *)&x,sizeof(long))==sizeof(long)) 
  474.  {
  475.    *l=ntohl(x);/* network to host long */
  476.    return 0;
  477.  }
  478. return -1;/* failed */
  479. }
  480. /*--------------------------------------------------------*/
  481. /* send a word lvalue across network              */
  482. /*--------------------------------------------------------*/
  483. int send_word(int s, short l)
  484. {
  485.    l=htons(l);/* host to network long */
  486.    if(write_data(s,(char *)&l,sizeof(long))==sizeof(long)) return 0;
  487.    return -1;/* Failed */
  488. }
  489. /*--------------------------------------------------------*/
  490. /* get  a word lvalue from network              */
  491. /*--------------------------------------------------------*/
  492. int get_word(int s, short *l)
  493. {
  494. short x;
  495. if(read_data(s,(char *)&x,sizeof(short))==sizeof(short))
  496.  {
  497.    *l=ntohs(x);/* network to host long */
  498.    return 0;
  499.  }
  500. return -1;/* failed */
  501. }
  502.  
  503. /*--------------------------------------------------------*/
  504. /* send a byte lvalue across network              */
  505. /*--------------------------------------------------------*/
  506. int send_byte(int s, char l)
  507. {
  508.    if(write_data(s,&l,sizeof(char))==sizeof(char)) return 0;
  509.    return -1;/* Failed */
  510. }
  511. /*--------------------------------------------------------*/
  512. /* get  a word lvalue from network              */
  513. /*--------------------------------------------------------*/
  514. int get_byte(int s, char *l)
  515. {
  516. if(read_data(s,l,sizeof(char))==sizeof(char))
  517.  {
  518.    return 0;
  519.  }
  520. return -1;/* failed */
  521. }
  522.  
  523. /*--------------------------------------------------------*/
  524. /* Conversation (or: How to talk between sockets)      */
  525. /* Now that you have a connection between sockets you want*/
  526. /* to send data between them. The read() and write()       */
  527. /* functions are used to do this, just as they are for      */
  528. /* normal files. There is only one major difference       */
  529. /* between socket reading and writing and file reading       */
  530. /* and writing: you don't usually get back the same number*/
  531. /* of characters that you asked for, so you must loop     */
  532. /* until you have read the number of characters that you  */
  533. /* want. A simple function to read a given number of      */
  534. /* characters into a buffer is:                  */
  535. /*--------------------------------------------------------*/
  536. int read_data(int s,char *buf,int n)
  537. { 
  538.   int bcount=0; /* counts bytes read */
  539.   int br=0;     /* bytes read this pass */
  540.   /* loop until full buffer */
  541.   while(bcount<n) 
  542.    { 
  543.      if ((br= read(s,buf,n-bcount)) > 0) 
  544.       {
  545.       bcount += br;                /* increment byte counter */
  546.       buf += br;                   /* move buffer ptr for next read */
  547.        }
  548.      else
  549.       if(br<0) return(-1);         /* signal an error to the caller */
  550.    }
  551.   return(bcount);
  552. }
  553. /*--------------------------------------------------------*/
  554. int write_data(int s,char *buf,int n)
  555. { 
  556.   int bcount=0; /* counts bytes read */
  557.   int br=0;     /* bytes read this pass */
  558.   /* loop until full buffer */
  559.   while(bcount<n) 
  560.    { 
  561.      if((br= write(s,buf,n-bcount)) > 0) 
  562.       {
  563.        bcount += br;                /* increment byte counter */
  564.        buf += br;                   /* move buffer ptr for next read */
  565.       }
  566.      else
  567.       if(br<0) return(-1);          /* signal an error to the caller */
  568.    }
  569.   return(bcount);
  570. }
  571. /*--------------------------------------------------------*/
  572. /* Determine hostent according to given name or current   */
  573. /* machine config                      */
  574. /*--------------------------------------------------------*/
  575. struct hostent *mygethostent(char *hostname)
  576. {
  577. struct hostent     *hp;
  578. static struct hostent dm;
  579. static unsigned char bf[4];
  580. static char *ls[2],myname[MAXHOSTNAME+1];
  581. char *cx;
  582. if(!hostname || !*hostname)
  583.  {
  584.   mygethostname(myname,MAXHOSTNAME);      /* who are we? */
  585.   if(hostname) strcpy(hostname,myname);
  586.   hostname=myname;
  587.  }
  588. if(*hostname>='0' && *hostname<='9')
  589.  {
  590.      char *c=hostname;
  591.      memset(bf,0,4);
  592.      /* assume dot adress */
  593.      bf[0]=atol(c);while(*c && *c!='.') c++;c++;
  594.      bf[1]=atol(c);while(*c && *c!='.') c++;c++;
  595.      bf[2]=atol(c);while(*c && *c!='.') c++;c++;
  596.      bf[3]=atol(c);
  597.      hp=&dm;
  598.      memset(hp,0,sizeof(dm));
  599.      hp->h_name=hostname;
  600.      hp->h_aliases=NULL;
  601.      hp->h_addrtype=2;
  602.      hp->h_length=4;
  603.      hp->h_addr_list=ls;
  604.      ls[0]=bf;ls[1]=NULL;
  605.    }
  606. else hp=gethostbyname(hostname);/* do we know the host's */
  607. return hp;/* return our static data */
  608. }
  609. /*--------------------------------------------------------*/
  610. /* Unlike with the telephone, you may still accept calls  */ 
  611. /* while processing previous connections. For this reason */
  612. /* you usually fork off jobs to handle  each connection.  */
  613. /* The following code shows how to use establish() and    */
  614. /* get_connection() to allow multiple connections to be   */
  615. /* dealt with:                          */
  616. /*--------------------------------------------------------*/
  617. /* wait for a connection to occur on a socket created with*/
  618. /* establish()                          *
  619. /*--------------------------------------------------------*/
  620. int get_connection(int s)
  621. { 
  622. int t;                  /* socket of connection */
  623. if ((t = accept(s,NULL,NULL)) < 0)   /* accept connection if there is one */
  624.     return(-1);
  625. if(sw_keepalive) sokeepalive(t);
  626. return(t);
  627. }
  628. /*--------------------------------------------------------*/
  629. /* Dialing (or: How to call a socket)              */
  630. /* You now know how to create a socket that will accept   */
  631. /*  incoming calls. So how do you call it? As with the       */
  632. /* telephone, you must first have the phone before using  */
  633. /* it  to call. You use the socket() function to do this, */
  634. /* exactly as you establish a socket to listen to.      */
  635. /* After getting a socket to make the call with, and      */
  636. /* giving it an address, you use the connect() function to*/
  637. /*  try to  connect to a listening socket. The            */
  638. /* following function calls a particular port number on a */
  639. /* particular host:                      */
  640. /*--------------------------------------------------------*/
  641. /* This function returns a connected socket through which */
  642. /*  data can flow.                      */
  643. /*--------------------------------------------------------*/
  644. int call_socket(char *hostname, unsigned short portnum)
  645. {
  646.   struct sockaddr_in sa;
  647.   struct hostent     *hp;
  648.   int a, s;
  649.   if((hp= mygethostent(hostname)) == NULL) { /* do we know the host's */
  650.     errno= ECONNREFUSED;                       /* address? */
  651.     return(-1);                                /* no */
  652.   }
  653.   memset(&sa,0,sizeof(sa));
  654.   memcpy((char *)&sa.sin_addr,hp->h_addr,hp->h_length);     /* set address */
  655.   sa.sin_family= hp->h_addrtype;
  656.   sa.sin_port= htons((unsigned short)portnum);
  657.  
  658.   printf("call_socket: calling %s type=%ld %s:%ld\n",
  659.     hostname,hp->h_addrtype,dumpadr(hp->h_addr,hp->h_length),(long)portnum);
  660.  
  661.   if ((s= socket(hp->h_addrtype,SOCK_STREAM,0)) < 0)     /* get socket */
  662.     return(-1);
  663.   if(sw_keepalive) sokeepalive(s);
  664.  
  665.   if (connect(s,(struct sockaddr *)&sa,sizeof sa) < 0) { /* connect */
  666.     close(s);
  667.     return(-1);
  668.   }
  669.   return(s);
  670. }
  671. /*--------------------------------------------------------*/
  672. /* Establish a socket; originally from bzs@bu-cs.bu.edu   */
  673. /*--------------------------------------------------------*/
  674. int establish(unsigned short portnum)
  675. {
  676.   int    s;
  677.   struct sockaddr_in sa;
  678.   struct hostent *hp;
  679.   char *cx;
  680.   static char myname[MAXHOSTNAME+1];
  681.   myname[0]=0;
  682.   if((hp= mygethostent(myname)) == NULL) { /* do we know the host's */
  683.     errno= ECONNREFUSED;                       /* address? */
  684.     return(-1);                                /* no */
  685.   }
  686.   printf("establish: %s adr type=%ld %s:%ld\n",
  687.     myname,hp->h_addrtype,dumpadr(hp->h_addr,hp->h_length),(long)portnum);
  688.   memset(&sa, 0, sizeof(struct sockaddr_in)); /* clear our address */
  689.   sa.sin_family= hp->h_addrtype;              /* this is our host address */
  690.   sa.sin_port= htons(portnum);                /* this is our port number */
  691.   if ((s= socket(AF_INET, SOCK_STREAM, 0)) < 0) /* create socket */
  692.     return(-1);
  693.   if(sw_keepalive) sokeepalive(s);
  694.  
  695.   if (bind(s,(struct sockaddr *)&sa,sizeof(struct sockaddr_in)) < 0) {
  696.     close(s);
  697.     return(-1);                               /* bind address to socket */
  698.   }
  699.   listen(s, 3);                               /* max # of queued connects */
  700.   return(s);
  701. }
  702. /*--------------------------------------------------------*/
  703. int mygethostname(char *hostname,int maxlen)
  704. {
  705. char *cx;
  706. gethostname(hostname,maxlen);           /* who are we? */
  707. /* libsocket for djgpp kludge */
  708. if(*hostname)
  709.    {
  710.      cx=hostname+strlen(hostname)-1;
  711.      while(cx>=hostname && *cx==' ') *cx--=0;
  712.    }
  713. return *hostname ? 1:-1;
  714. }
  715. /*--------------------------------------------------------*/
  716. char *dumpadr(char *s,long len)
  717. {
  718. char *c;
  719. static char buf[500];
  720. long i;
  721. //printf("dumpadr: [%08lx] %ld\n",s,len);
  722. if(len>500-1) len=500-1;
  723. for(i=0,c=buf;i<len;i++) 
  724.  {
  725.    sprintf(c,"%03ld.",(unsigned long) ((UBYTE)*s++) );c+=4;
  726.  }
  727. *--c=0;/* remove last . */
  728. return buf;
  729. }
  730. /*--------------------------------------------------------*/
  731. void memdump(void *s,long len,long adr)
  732. {
  733. UBYTE *c=s;
  734. long i;
  735. for(i=0;i<len;i+=0x10,c+=0x10,adr+=0x10) 
  736.  printf("%08lX: %02lX%02lX%02lX%02lX %02lX%02lX%02lX%02lX %02lX%02lX%02lX%02lX %02lX%02lX%02lX%02lX\n",
  737.        adr,
  738.        c[0x0],c[0x1],c[0x2],c[0x3],
  739.        c[0x4],c[0x5],c[0x6],c[0x7],
  740.        c[0x8],c[0x9],c[0xa],c[0xb],
  741.        c[0xc],c[0xd],c[0xe],c[0xf]);
  742. }
  743. /*--------------------------------------------------------*/
  744. /* return hexval+1                      */
  745. /*--------------------------------------------------------*/
  746. UBYTE ishex(UBYTE c)
  747. {
  748. if((c>='0' && c<='9')) c=c-('0'-1);
  749. else
  750.  {
  751.   c|=0x20;/* lowercase */
  752.   if(c>='a' && c<='f'  ) c=c-('a'-10-1);
  753.   else c=0;
  754.  }
  755. return c;
  756. }
  757. /*--------------------------------------------------------*/
  758. long my_htol(char *s,char **ds)
  759. {
  760. register long l=0,sg;
  761. register UBYTE ch;
  762. if(*s=='-') {s++;sg=1;}else sg=0;
  763. /*----------------------------------*/
  764. /* Skip first  chars if they are    */
  765. /* '$' , '0x' or '0X'             */
  766. /*----------------------------------*/
  767. if(*s=='$') s++;
  768. if(*s=='0' && (s[1]|0x20)=='x') s+=2;
  769. while((ch=ishex(*s))!=0)
  770.  {
  771.    l=(l<<4)+(ch-1);
  772.    s++;
  773.  }
  774. if(ds) *ds=s;/* Update ptr */
  775. return sg ? -l:l;
  776. }
  777. /*--------------------------------------------------------*/
  778. long ntol(char *s)
  779. {
  780. long num;
  781. if(*s=='0' && (s[1]|0x20)=='x') num=my_htol(s,NULL);
  782. else                 num=atol(s);
  783. return num;
  784. }
  785. /*--------------------------------------------------------*/
  786. char *htoa(long n,char ln)
  787. {
  788. register char *cx,c,h;
  789. static char buf[9];
  790. if(ln==0) ln=8;
  791. buf[ln]=0;cx=buf+ln-1;
  792. for(c=ln;c;c--,n>>=4,cx--)
  793.  {
  794.    h=n&0xF;
  795.    if(h>=10) *cx=h+('A'-10);else *cx=h+'0';
  796.  }
  797. return buf;
  798. }
  799. /*--------------------------------------------------------*/
  800. /*--------------------------------------------------------*/
  801. #define TIMEOFFSET ((((1978-1970)*365+2)*24+1)*60*60) // 252464400.00000 , 0xF0C4D10
  802. #define ADJUST (4*60*60)
  803.  
  804. #if 1 //ifndef AMIGA
  805. void CurrentTime(ULONG *s,ULONG *m)
  806. {
  807. struct timeval tv;
  808. struct timezone tz;
  809. tz.tz_minuteswest=0;
  810. tz.tz_dsttime=0;
  811. gettimeofday(&tv,&tz);
  812. if(s) *s  =(ULONG)tv.tv_sec-TIMEOFFSET+ADJUST;
  813. if(m) *m  =(ULONG)tv.tv_usec;
  814. }
  815. #endif
  816.  
  817. /* Calc  *(m1)=m2-m1; */
  818. void DiffTime(ULONG *s1,ULONG *m1,ULONG s2,ULONG m2)
  819. {
  820. if(*m1>m2) {m2+=1000000L;s2--;}
  821. (*m1)=m2-*m1;
  822. (*s1)=s2-*s1;
  823. }
  824.  
  825. char *SPrintTime(ULONG s,ULONG m)
  826. {
  827. static char buf[50];
  828. ULONG day,hour,min;
  829. day  = s/(24*60*60L);s-=day*(24*60*60L);
  830. hour = s/(60*60L)   ;s-=hour*(60*60L);
  831. min  = s/60         ;s-=min*60;
  832. /* DD.HH:MM:SS.TT */
  833. sprintf(buf,"%02ld|%02ld:%02ld:%02ld.%06ld\n",
  834.     day,hour,min,s,m);
  835. return buf;
  836. }
  837.  
  838. long memrnd(void *d,long sd,long len)
  839. {
  840. UBYTE *p=d;
  841. if(sd!=-1) RangeSeed(sd);
  842. while(len--) *p++=RangeRand(256);
  843. return sd;
  844. }
  845.  
  846. void memcsum(void *d,ULONG *cs,long len)
  847. {
  848. UBYTE *p=d;
  849. ULONG c=*cs;
  850. while(len--) c+=*p++;
  851. *cs=c;
  852. }
  853. /*--------------------------------------------------------*/
  854. static unsigned long seed=0;
  855. /*--------------------------------------------------------*/
  856. unsigned long RangeSeed(unsigned long s)
  857. {
  858. unsigned long o=seed;
  859. printf("RangeSeed: 0x%08lx\n",s);
  860. seed=s;
  861. return o;
  862. }
  863. /*--------------------------------------------------------*/
  864. unsigned short int RangeRand(int d6)
  865. {
  866. unsigned long d0,d1;
  867. unsigned short int d4,d5;
  868. d5=(unsigned short int)d6;
  869. d4=d5-1;d0=seed;
  870. do
  871.  {
  872.   d1=d0;d0+=d0;
  873.   if(d0<=d1) d0^=0x1d872b41;
  874.   d4>>=1;
  875.  } while(d4);
  876. seed=d0;
  877. if(d5) 
  878.  {
  879.   d0=d5*(d0&0xFFFF);
  880.   return (unsigned short int)(d0>>16L);
  881.  }
  882. return (unsigned short int)(d0&0xFFFF);
  883. }
  884.  
  885.  
  886.  
  887. #if 0
  888. /*
  889.  
  890. A very similar function should be used to write data; we leave that function
  891. as an exercise to the reader.
  892.  
  893. Hanging Up (or: What to do when you're done with a socket)
  894.  
  895. Just as you hang up when you're through speaking to someone over the
  896. telephone, so must you close a connection between sockets. The normal
  897. close() function is used to close each end of a socket connection. If one
  898. end of a socket is closed and the other tries to write to its end, the write
  899. will return an error.
  900.  
  901. Speaking The Language (or: Byte order is important)
  902.  
  903. Now that you can talk between machines, you have to be careful what you say.
  904. Many machines use differing dialects, such as ASCII versus (yech) EBCDIC.
  905. More commonly there are byte-order problems. Unless you always pass text,
  906. you'll run up against the byte-order problem. Luckily people have already
  907. figured out what to do about it.
  908.  
  909. Once upon a time in the dark ages someone decided which byte order was
  910. "right". Now there exist functions that convert one to the other if
  911. necessary. Some of these functions are htons() (host to network short
  912. integer), ntohs() (network to host short integer), htonl() (host to network
  913. long integer), and ntohl() (network to host long integer). Before sending an
  914. integer through a socket, you should first massage it with the htonl()
  915. function:
  916.  
  917. i= htonl(i);
  918. write_data(s, &i, sizeof(i));
  919.  
  920. and after reading data you should convert it back with ntohl():
  921.  
  922. read_data(s, &i, sizeof(i));
  923. i= ntohl(i);
  924.  
  925. If you keep in the habit of using these functions you'll be less likely to
  926. goof it up in those circumstances where it is necessary.
  927.  
  928. The Future Is In Your Hands (or: What to do now)
  929.  
  930. Using just what's been discussed here, you should be able to build your own
  931. programs that communicate with sockets. As with all new things, however, it
  932. would be a good idea to look at what's already been done. While there are
  933. not a lot of books describing BSD sockets, one good reference is Unix
  934. Network Programming by W. Richard Stevens (Prentice-Hall 1990, ISBN
  935. 0-13-949876-1). In addition, you should look at some of the many
  936. public-domain applications which make use of sockets, since real
  937. applications are the best teachers. One such application is msend, a utility
  938. used to send messages between users on different hosts.
  939.  
  940. Beware that the examples given here leave out a lot of error checking which
  941. should be used in a real application. You should check the manual pages for
  942. each of the functions discussed here for further information. If you have
  943. specific questions regarding sockets, please feel free to ask me at
  944. jimf@world.std.com.
  945. */
  946.  
  947. #if 0
  948.    printf("reading 256 ..\n");
  949.    l=read_data(s,buf,256);
  950.    printf("read %d bytes.\n",l);
  951.    for(i=0,c=buf;i<l;i+=0x10,c+=0x10) 
  952.      printf("%02lX%02lX%02lX%02lX %02lX%02lX%02lX%02lX %02lX%02lX%02lX%02lX %02lX%02lX%02lX%02lX\n",
  953.        c[0x0],c[0x1],c[0x2],c[0x3],
  954.        c[0x4],c[0x5],c[0x6],c[0x7],
  955.        c[0x8],c[0x9],c[0xa],c[0xb],
  956.        c[0xc],c[0xd],c[0xe],c[0xf]);
  957.    printf("receive_data: closing socket.\n");
  958.    close(s);
  959.    printf("done.. returning.\n");
  960. #endif
  961. #endif
  962.  
  963. /*========================================================*/
  964. /*-END OF SOURCE (stest.c)      --------------------------*/
  965. /*========================================================*/
  966.  
  967.